home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Online / MagPLIP / source / linport.asm < prev    next >
Assembly Source File  |  1998-04-02  |  12KB  |  463 lines
  1. ;
  2. ;  $VER$;
  3. ;  linplip.device - Parallel Line Internet Protocol
  4. ;
  5. ;  Assembler routines for efficient port handling.
  6. ;
  7. ;  Written by Stéphane Zermatten, based on the code written
  8. ;  by Oliver Wagner and Michael Balzer, and modified by 
  9. ;  Marius Gröger. 
  10. ;  
  11. ;  (C) Copyright 1997 Stéphane Zermatten
  12. ;      All Rights Reserved
  13. ;
  14. ;  HISTORY:
  15. ;
  16. ;  1.3 (97.10.26 23:18:33)      -- Protocol changed (once again)
  17. ;                                  to lighten the charge of the
  18. ;                                  68k CPU (I suppose the PC more
  19. ;                                  powerful)
  20. ;  1.2 (97.10.25 16:34:24)      -- Receive protocol changed. 
  21. ;                                  Now, 3 nibbles are used, instead of 4. 
  22. ;  1.1 (97.10.25 08:20:23)      -- initial revision
  23. ;                                  based on a C version of linport
  24. ;
  25. ; 
  26. ;  FUTUR CHANGES
  27. ;
  28. ;   I'm working on an interrupt-based version, to see which 
  29. ;   approach is better.    
  30. ; 
  31.  
  32.       section "text",code
  33.  
  34.  
  35. ;----------------------------------------------------------------------------
  36.  
  37.  
  38.       IFND HARDARE_CIA_I
  39.       include "hardware/cia.i"
  40.       ENDC
  41.  
  42.       IFND EXEC_MACROS_I
  43.       include "exec/macros.i"
  44.       ENDC
  45.  
  46.       IFND MAGPLIP_I
  47.       include "magplip.i"
  48.       ENDC
  49.  
  50.  
  51. ;----------------------------------------------------------------------------
  52.  
  53.  
  54.       xdef    _interrupt
  55.       xdef    _hwsend
  56.       xdef    _hwrecv
  57.  
  58. ;----------------------------------------------------------------------------
  59.  
  60. ciaa     equ     $bfe001
  61. ciab     equ     $bfd000
  62. BaseAX   equ     ciab+ciapra
  63.  
  64. OutReg   equ     ciaa+ciaprb
  65. StatusReg equ    ciab+ciapra
  66.  
  67. OUTB_BUSY equ 4
  68.  
  69.  
  70. ;----------------------------------------------------------------------------
  71. ;
  72. ; NAME
  73. ;     interrupt() - ICR FLG interrupt server
  74. ;
  75. ; SYNOPSIS
  76. ;     void interrupt(struct PLIPBase *)
  77. ;                    A1
  78. ;
  79. ; FUNCTION
  80. ;     This is called from CIA resource on the receipt of an parallel port
  81. ;     FLG line interrupt. This is the case if the other side starts
  82. ;     transmission and writes the first byte to our port.
  83. ;
  84. ;     We recognise this here and propagate the information to the server
  85. ;     task by Signal()ing it and by setting the PLIPB_RECEIVING bit
  86. ;     in the flags field.
  87. ;
  88. ;----------------------------------------------------------------------------
  89.  
  90. _interrupt:
  91.     
  92.     btst    #PLIPB_RECEIVING,pb_Flags(a1)  
  93.     bne.s   setack          
  94.                     ; PLIPF_RECEIVING&pb_Flags == 0
  95.  
  96.     move.b  StatusReg,d0            ; PAR_STATUS==CIAF_PRTRPOUT ? 
  97.     andi.b  #7,d0
  98.     cmp.b   #2,d0   
  99.     bne.s   skipint
  100.  
  101.     bset    #PLIPB_RECEIVING,pb_Flags(a1)
  102.     move.l  pb_IntSigMask(a1),d0
  103.     movea.l pb_SysBase(a1),a6       ; Signal
  104.     movea.l pb_Server(a1),a1
  105. gosig:  
  106. ;       movem.l a6,-(sp)                ; ExecBase is not in a6...
  107.     JSRLIB  Signal
  108. ;       movem.l (sp)+,a6
  109. skipint: 
  110.     moveq #0,d0                     ; set Z flag => next server
  111.     rts
  112.  
  113. setack:                                 ; PLIPF_RECEIVING&pb_Flags != 0
  114.     bset.b  #PLIPEB_NIBBLEACK,(pb_ExtFlags+1)(a1)
  115.     moveq #0,d0                     ; set Z flag => next server
  116.     rts
  117.  
  118.  
  119. ;----------------------------------------------------------------------------
  120. ;
  121. ; NAME
  122. ;     send_bit() - writes one byte to the parallel port
  123. ;
  124. ; SYNOPSIS
  125. ;     ULONG send_bit(UBYTE *TimeoutSet, UBYTE)
  126. ;                       a2               d0
  127. ;
  128. ;
  129. ; FUNCTION
  130. ;     This function writes one byte to the parallel port.
  131. ;     Implemented in a really stupid way (using loops),
  132. ;     but I can't see how I could use signals or interrupts
  133. ;     without changing the protocol.
  134. ;
  135. ; RESULT -> D0, Z
  136. ;     0         All went right
  137. ;     1         Timeout
  138. ;       
  139. ;----------------------------------------------------------------------------
  140. _send_bit:
  141.     move.l  d0,d1                   ; data -> d1
  142.  
  143.     andi.b  #$0f,d0                 ; first 4 bits 0-3
  144.     move.b  d0,OutReg
  145.     bset    #OUTB_BUSY,d0           ; BUSY on
  146.     move.b  d0,OutReg               ; bset #OUTB_BUSY,OutReg won't work 
  147.  
  148. loop1:                                  ; wait for BUSY on or Timeout
  149.     tst.b   (a2)
  150.     bne     snd_timeout
  151.     btst    #CIAB_PRTRBUSY,StatusReg
  152.     beq.s   loop1
  153.  
  154.     lsr.b   #4,d1                   ; last bits 4-7
  155.     bset    #OUTB_BUSY,d1
  156.     move.b  d1,OutReg
  157.     bclr    #OUTB_BUSY,d1           ; BUSY off
  158.     move.b  d1,OutReg               ; bclr #OUTB_BUSY,OutReg won't work
  159.  
  160. loop2:
  161.     tst.b   (a2)                    ; wait for BUSY off or Timeout
  162.     bne     snd_timeout
  163.     btst    #CIAB_PRTRBUSY,StatusReg
  164.     bne.s   loop2
  165.  
  166.     
  167. ;allright:
  168.     moveq   #0,d0                   ; return OK
  169.     rts
  170.  
  171. snd_timeout: 
  172.     moveq   #1,d0                   ; return TIMEOUT
  173.     rts
  174.  
  175. ;----------------------------------------------------------------------------
  176. ;
  177. ; NAME
  178. ;     receive_bit() - reads one byte from the parallel port
  179. ;
  180. ; SYNOPSIS
  181. ;     ULONG receive_bit(volatile UBYTE *timeoutset, UBYTE *ExtFlags + 1, UBYTE busystate)
  182. ;                               a2                        a0                     d2
  183. ;
  184. ;
  185. ; FUNCTION
  186. ;     This function reads one byte from the parallel port, 
  187. ;     relying on messages sent by the interrupt. 
  188. ;
  189. ; ARGUMENTS
  190. ;
  191. ;     timeoutset        : the byte at this address is checked periodically
  192. ;                         and the function returns an error if a non-null
  193. ;                         value is found there.
  194. ;     ExtFlags+1        : The bit 1 of this byte contains the flag NIBBLEACK
  195. ;                         set by the interrupt = ((UBYTE *)pb->pb_ExtFlags)+1
  196. ;     busystate         : The state in which the BUSY output line was left
  197. ;                         by a previous call of this function of hwrecv.
  198. ;                         value : 0x00 or 0x10
  199. ;
  200. ; RESULT
  201. ;  Dans d0 (et dans Z)
  202. ;     0         All went right
  203. ;     1         Timeout 
  204. ;  Dans d1 : 
  205. ;     Le bit lu
  206. ;
  207. ; NOTE
  208. ;     a0 and a2 are left untouched ! guaranteed  !
  209. ; 
  210. ;     I've tried a version using signals sent by the interrupt instead
  211. ;     of those stupid loops, but it's too slow. (about 3 times as slow)
  212. ;
  213. ;----------------------------------------------------------------------------
  214. _receive_bit:
  215.  
  216. WAITFOR_NIBBLEACK       MACRO   ; should be a function, but I'm looking for speed               
  217. rloop\@:
  218.     tst.b   (a2)
  219.     bne     rcv_timeout
  220.     btst.b  #PLIPEB_NIBBLEACK,(a0)
  221.     beq     rloop\@
  222.     
  223.     bclr.b  #PLIPEB_NIBBLEACK,(a0)
  224.     ENDM
  225.  
  226. RECV_ACKNOWLEDGE        MACRO   ; invert the state of the output BUSY line (uses d2)
  227.     bchg    #OUTB_BUSY,d2
  228.     move.b  d2,OutReg
  229.     ENDM                            
  230.  
  231.  
  232.     WAITFOR_NIBBLEACK
  233.  
  234.     ; d1 = in_sbp()
  235.     clr.b   d1
  236.  
  237.     move.b  StatusReg,d1            ; statusreg -> d1 
  238.     RECV_ACKNOWLEDGE
  239.  
  240.     andi.b  #7,d1
  241.  
  242.     WAITFOR_NIBBLEACK
  243.  
  244.     ; d1 |= in_sbp()<<3
  245.     move.b  StatusReg,d0
  246.     RECV_ACKNOWLEDGE
  247.  
  248.     andi.b  #7,d0
  249.     lsl.b   #3,d0
  250.     eor.b   d0,d1
  251.  
  252.     WAITFOR_NIBBLEACK       
  253.  
  254.     ; d1 |= in_sbp() << 6
  255.     move.b  StatusReg,d0
  256.     RECV_ACKNOWLEDGE
  257.  
  258.     andi.b  #3,d0
  259.     lsl.b   #6,d0
  260.     eor.b   d0,d1
  261.  
  262. ;allright:
  263.     moveq   #0,d0                   ; return OK
  264.     rts
  265.  
  266. rcv_timeout: 
  267.     moveq  #1,d0                    ; return TIMEOUT
  268.     rts
  269.  
  270.  
  271. ;----------------------------------------------------------------------------
  272. ;
  273. ; NAME
  274. ;    hwrecv(struct PLIPBase *) - receive a frame from the parallel port
  275. ;           a0
  276. ;
  277. ; FUNCTION
  278. ;    First allocate a signal from the current task and set pb_ModSigMask and
  279. ;    pb_ModTask for the interrpution. 
  280. ;    Then, it acknowledge the beginning of a packet by sending 0x02 (SELECT),
  281. ;    gets the size, the data and the checksum (one byte). 
  282. ;    
  283. ; RESULT
  284. ;    boolean (ULONG) 
  285. ;    TRUE => OK
  286. ;    FALSE => ERROR
  287. ;
  288. ;----------------------------------------------------------------------------
  289. _hwrecv:
  290.     movem.l d2-d7/a2-a5,-(sp)
  291.  
  292.     movea.l a0,a5                   ; pb -> a5
  293.     lea.l   pb_TimeoutSet(a5),a2    ; &pb->pb_TimeoutSet -> a2 (pour receive_bit)
  294.     lea.l   (pb_ExtFlags+1)(a5),a0  ; &pb->pb_ExtFlags+1 -> a0 (pour receive_bit)
  295.     movea.l pb_Frame(a5),a3         ; frame 
  296.     lea.l   pf_DstAddr(a3),a4       ; &frame->data -> a4
  297.     lea.l   pf_Size(a3),a3          ; &frame->pf_Size -> a3
  298.     moveq   #0,d2                   ; state of the BUSY output (pour receive_bit)
  299.  
  300.     moveq   #0,d4                   ; retval = d4 (ERROR=0)
  301.  
  302.     bclr.b  #PLIPEB_NIBBLEACK,(a0)
  303.  
  304.     moveq   #2,d0
  305.     move.b  d0,OutReg               ; Acknowledge
  306.  
  307.     clr.w   d5                      ; d5 = data_len
  308.  
  309.     jsr     _receive_bit            ; Lower part of Length
  310.     bne.s   ffrec_error
  311.     move.b  d1,d5                   ; -> d5 (low)
  312.  
  313.  
  314.     jsr     _receive_bit            ; Upper part of Length
  315.     bne.s   ffrec_error
  316.     lsl.w   #8,d1
  317.     eor.w   d1,d5
  318.     beq.s   ffrec_error             ; size == 0 ?
  319.  
  320.  
  321.     move.w  d5,(a3)                 ; d5 -> pf_Size 
  322.  
  323.     move.l  pb_MTU(a5),d0
  324.     add.w   #PKTFRAMESIZE_2,d0
  325.     cmp.w   d5,d0
  326.     blt.s   ffrec_error             ; d0<d5=data_len Too big ? 
  327.     tst.w   d5
  328.     blt.s   ffrec_error             ; d5 < 0 ??
  329.  
  330.  
  331.     subq.w  #1,d5                   ; d5 = size-1 (better for loops)
  332.     move.w  d5,d6                   ; d6 = size-1 (for checksum loop)
  333. dataloop:                               ; do {
  334.     jsr     _receive_bit
  335.     bne.s   ffrec_error
  336.     move.b  d1,(a4)+
  337.     dbf.w   d5,dataloop             ; }while(--d5!=-1);
  338.  
  339.  
  340.     clr.b   d5                      ; Checksum -> d5
  341. checkloop:                              ; do {
  342.     add.b   -(a4),d5
  343.     dbf.w   d6,checkloop            ; }while(--d6!=-1);
  344.  
  345.     jsr     _receive_bit
  346.     bne.s   ffrec_error
  347.  
  348.  
  349.     cmp.b   d5,d1                   ; Checksum OK ?
  350.     bne.s   ffrec_error
  351.  
  352.                     ; Clean up the port
  353.     moveq   #1,d4                   ; return OK
  354.  
  355.     tst.b   d2                      ; d2==0 ? 
  356.     beq.s   ffrec_error             ; Not an error. Skipping
  357.  
  358. lineloop:                               ; Clean the line. 
  359.     tst.b   (a2)
  360.     bne     ffrec_error             ; The retval stays to TRUE
  361.     btst.b  #PLIPEB_NIBBLEACK,(a0)
  362.     beq     lineloop
  363.  
  364. ffrec_error:
  365.     clr.b   OutReg
  366.     bclr    #PLIPB_RECEIVING,pb_Flags(a5)
  367.     move.l  d4,d0                   ; return retval
  368. frrec_end:
  369.     movem.l (sp)+,d2-d7/a2-a5
  370.     rts
  371.  
  372. ;----------------------------------------------------------------------------
  373. ;
  374. ; NAME
  375. ;    hwsend(struct PLIPBase *) - receive a frame to the parallel port
  376. ;           a0
  377. ;
  378. ; FUNCTION
  379. ;    First, it triggers the other side by sending an ACK signal, and
  380. ;    then it waits for an answer (a SEL signal).
  381. ;    It sends : two bytes containing the size, the data, and a crc (1 byte)
  382. ;    
  383. ; RESULT
  384. ;    boolean (ULONG) 
  385. ;    TRUE => OK
  386. ;    FALSE => ERROR
  387. ;
  388. ;----------------------------------------------------------------------------
  389. _hwsend:
  390.     movem.l d4-d6/a2-a6,-(sp)
  391.  
  392.     movea.l a0,a5                   ; pb -> a5
  393.     lea.l   pb_TimeoutSet(a5),a2    ; &pb->pb_TimeoutSet -> a2 (for send_bit)
  394.     movea.l pb_Frame(a5),a3         ; frame 
  395.     lea.l   pf_DstAddr(a3),a4       ; data -> a4
  396.     lea.l   pf_Size(a3),a3          ; *size -> a3
  397.     lea.l   pb_Flags(a5),a0         ; *pb_Flags -> a0 (temporary !)
  398.  
  399.     moveq   #0,d4                   ; d4=retval=FALSE (error)
  400.  
  401.     btst    #PLIPB_RECEIVING,(a0)
  402.     bne     snd_error               ; Collision ?
  403.  
  404.     moveq   #8,d0
  405.     move.b  d0,OutReg               ; Trigger
  406.  
  407. sndloop0:
  408.     tst.b   (a2)                    ; TimeoutSet ?
  409.     bne     snd_error
  410.     btst    #PLIPB_RECEIVING,(a0)
  411.     bne     snd_error
  412.     btst    #CIAB_PRTRSEL,StatusReg
  413.     beq.s   sndloop0                ; }while(!(StatusReg&CIAF_PRTRSEL));
  414.  
  415.     movea.l pb_CIAABase(a5),a6      ; CIAABase -> a6
  416.     moveq   #CIAICRF_FLG,d0
  417.     JSRLIB  AbleICR                 ; Disable interrupt
  418.  
  419.     move.w  (a3),d5                 ; data_len -> d5
  420.     move.b  d5,d0                   ; Send lower byte of Size
  421.     jsr     _send_bit
  422.     bne     snd_inton
  423.  
  424.     move.w  d5,d0
  425.     lsr.w   #8,d0                   ; Send upper byte of Size
  426.     jsr     _send_bit
  427.     bne     snd_inton
  428.  
  429.     subq.w  #1,d5                   ; d5=size-1 (for loops)
  430.     move.w  d5,d6                   ; d6=size-1
  431.  
  432. sndmainloop:                            ; do{
  433.     move.b  (a4)+,d0
  434.     jsr     _send_bit
  435.     bne     snd_inton
  436.     dbf.w   d5,sndmainloop          ; }while(--d5!=-1)
  437.  
  438.     clr.b   d0                      ; checksum -> d0
  439. sndchecksum:
  440.     add.b   -(a4),d0
  441.     dbf.w   d6,sndchecksum          ; }while(--d6!=-1)
  442.  
  443.     jsr     _send_bit       
  444.     bne     snd_inton
  445.  
  446.     moveq   #1,d4                   ; retval = TRUE (OK)
  447.  
  448. snd_inton:
  449.     moveq   #CIAICRF_FLG,d0
  450.     JSRLIB  SetICR                  ; Clear interrupt
  451.     move.w  #CIAICRF_FLG|CIAICRF_SETCLR,d0
  452.     JSRLIB  AbleICR                 ; Enable interrupt
  453.  
  454. snd_error:
  455.     clr.b   OutReg                  ; put the line back into order
  456.     move.b  d4,d0
  457.  
  458. snd_end:
  459.     movem.l (sp)+,d4-d6/a2-a6
  460.     rts
  461.  
  462.      end
  463.